home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 October: Mac OS SDK / Dev.CD Oct 00 SDK1.toast / Development Kits / Cross Platform / QuickTime 4.1.2 Windows SDK / CIncludes / CardServices.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-04-12  |  31.5 KB  |  909 lines  |  [TEXT/R*ch]
  1. /*
  2.      File:        CardServices.h
  3.  
  4.      Contains:    The client interface to Card and Socket Services.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    QuickTime 4.1
  8.  
  9.      Copyright:    (c) 1994-1999 by Apple Computer, Inc. All rights reserved.
  10.  
  11.      Bugs?:        For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. */
  17. #ifndef __CARDSERVICES__
  18. #define __CARDSERVICES__
  19.  
  20. #ifndef __MACTYPES__
  21.     #include <MacTypes.h>
  22. #endif
  23.  
  24. #ifndef __PCCARDTUPLES__
  25.     #include <PCCardTuples.h>
  26. #endif
  27.  
  28. #ifndef __MIXEDMODE__
  29.     #include <MixedMode.h>
  30. #endif
  31.  
  32.  
  33.  
  34.  
  35. #if PRAGMA_ONCE
  36. #pragma once
  37. #endif
  38.  
  39. #ifdef __cplusplus
  40. extern "C" {
  41. #endif
  42.  
  43. #if PRAGMA_IMPORT
  44. #pragma import on
  45. #endif
  46.  
  47. #if PRAGMA_STRUCT_ALIGN
  48.     #pragma options align=mac68k
  49. #elif PRAGMA_STRUCT_PACKPUSH
  50.     #pragma pack(push, 2)
  51. #elif PRAGMA_STRUCT_PACK
  52.     #pragma pack(2)
  53. #endif
  54.  
  55. /*    miscellaneous*/
  56.  
  57. enum {
  58.     CS_MAX_SOCKETS                = 32                            /* a long is used as a socket bitmap*/
  59. };
  60.  
  61.  
  62. /* Will move to <Traps.h>*/
  63. enum {
  64.     _PCCardDispatch                = 0xAAF0                        /* Card Services entry trap*/
  65. };
  66.  
  67. /* Will move to <Errors.h>*/
  68.  
  69. /*    result codes*/
  70.  
  71. enum {
  72.     kCSBadAdapterErr            = -9050,                        /* invalid adapter number*/
  73.     kCSBadAttributeErr            = -9051,                        /* specified attributes field value is invalid*/
  74.     kCSBadBaseErr                = -9052,                        /* specified base system memory address is invalid*/
  75.     kCSBadEDCErr                = -9053,                        /* specified EDC generator specified is invalid*/
  76.     kCSBadIRQErr                = -9054,                        /* specified IRQ level is invalid*/
  77.     kCSBadOffsetErr                = -9055,                        /* specified PC card memory array offset is invalid*/
  78.     kCSBadPageErr                = -9056,                        /* specified page is invalid*/
  79.     kCSBadSizeErr                = -9057,                        /* specified size is invalid*/
  80.     kCSBadSocketErr                = -9058,                        /* specified logical or physical socket number is invalid*/
  81.     kCSBadTypeErr                = -9059,                        /* specified window or interface type is invalid*/
  82.     kCSBadVccErr                = -9060,                        /* specified Vcc power level index is invalid*/
  83.     kCSBadVppErr                = -9061,                        /* specified Vpp1 or Vpp2 power level index is invalid*/
  84.     kCSBadWindowErr                = -9062,                        /* specified window is invalid*/
  85.     kCSBadArgLengthErr            = -9063,                        /* ArgLength argument is invalid*/
  86.     kCSBadArgsErr                = -9064,                        /* values in argument packet are invalid*/
  87.     kCSBadHandleErr                = -9065,                        /* clientHandle is invalid*/
  88.     kCSBadCISErr                = -9066,                        /* CIS on card is invalid*/
  89.     kCSBadSpeedErr                = -9067,                        /* specified speed is unavailable*/
  90.     kCSReadFailureErr            = -9068,                        /* unable to complete read request*/
  91.     kCSWriteFailureErr            = -9069,                        /* unable to complete write request*/
  92.     kCSGeneralFailureErr        = -9070,                        /* an undefined error has occurred*/
  93.     kCSNoCardErr                = -9071,                        /* no PC card in the socket*/
  94.     kCSUnsupportedFunctionErr    = -9072,                        /* function is not supported by this implementation*/
  95.     kCSUnsupportedModeErr        = -9073,                        /* mode is not supported*/
  96.     kCSBusyErr                    = -9074,                        /* unable to process request at this time - try later*/
  97.     kCSWriteProtectedErr        = -9075,                        /* media is write-protected*/
  98.     kCSConfigurationLockedErr    = -9076,                        /* a configuration has already been locked*/
  99.     kCSInUseErr                    = -9077,                        /* requested resource is being used by a client*/
  100.     kCSNoMoreItemsErr            = -9078,                        /* there are no more of the requested item*/
  101.     kCSOutOfResourceErr            = -9079                            /* Card Services has exhausted the resource*/
  102. };
  103.  
  104.  
  105.  
  106. /*    messages sent to client's event handler*/
  107.  
  108. enum {
  109.     kCSNullMessage                = 0x00,                            /* no messages pending (not sent to clients)*/
  110.     kCSCardInsertionMessage        = 0x01,                            /* card has been inserted into the socket*/
  111.     kCSCardRemovalMessage        = 0x02,                            /* card has been removed from the socket*/
  112.     kCSCardLockMessage            = 0x03,                            /* card is locked into the socket with a mechanical latch*/
  113.     kCSCardUnlockMessage        = 0x04,                            /* card is no longer locked into the socket*/
  114.     kCSCardReadyMessage            = 0x05,                            /* card is ready to be accessed*/
  115.     kCSCardResetMessage            = 0x06,                            /* physical reset has completed*/
  116.     kCSInsertionRequestMessage    = 0x07,                            /* request to insert a card using insertion motor*/
  117.     kCSInsertionCompleteMessage    = 0x08,                            /* insertion motor has finished inserting a card*/
  118.     kCSEjectionRequestMessage    = 0x09,                            /* user or other client is requesting a card ejection*/
  119.     kCSEjectionFailedMessage    = 0x0A,                            /* eject failure due to electrical/mechanical problems*/
  120.     kCSPMResumeMessage            = 0x0B,                            /* power management resume (TBD)*/
  121.     kCSPMSuspendMessage            = 0x0C,                            /* power management suspend (TBD)*/
  122.     kCSResetPhysicalMessage        = 0x0D,                            /* physical reset is about to occur on this card*/
  123.     kCSResetRequestMessage        = 0x0E,                            /* physical reset has been requested by a client*/
  124.     kCSResetCompleteMessage        = 0x0F,                            /* ResetCard() background reset has completed*/
  125.     kCSBatteryDeadMessage        = 0x10,                            /* battery is no longer useable, data will be lost*/
  126.     kCSBatteryLowMessage        = 0x11,                            /* battery is weak and should be replaced*/
  127.     kCSWriteProtectMessage        = 0x12,                            /* card is now write protected*/
  128.     kCSWriteEnabledMessage        = 0x13,                            /* card is now write enabled*/
  129.     kCSClientInfoMessage        = 0x14,                            /* client is to return client information*/
  130.     kCSSSUpdatedMessage            = 0x15,                            /* AddSocketServices/ReplaceSocket services has changed SS support*/
  131.     kCSFunctionInterruptMessage    = 0x16,                            /* card function interrupt*/
  132.     kCSAccessErrorMessage        = 0x17,                            /* client bus errored on access to socket*/
  133.     kCSCardUnconfiguredMessage    = 0x18,                            /* a CARD_READY was delivered to all clients and no client */
  134.                                                                 /*    requested a configuration for the socket*/
  135.     kCSStatusChangedMessage        = 0x19                            /* status change for cards in I/O mode*/
  136. };
  137.  
  138. /*
  139.     The following is a mapping of the PCMCIA name space to the Macintosh name space.
  140.     These two enum lists will be removed and given to developers as a separate file.
  141. */
  142. enum {
  143.     SUCCESS                        = noErr,
  144.     BAD_ADAPTER                    = kCSBadAdapterErr,
  145.     BAD_ATTRIBUTE                = kCSBadAttributeErr,
  146.     BAD_BASE                    = kCSBadBaseErr,
  147.     BAD_EDC                        = kCSBadEDCErr,
  148.     BAD_IRQ                        = kCSBadIRQErr,
  149.     BAD_OFFSET                    = kCSBadOffsetErr,
  150.     BAD_PAGE                    = kCSBadPageErr,
  151.     BAD_SIZE                    = kCSBadSizeErr,
  152.     BAD_SOCKET                    = kCSBadSocketErr,
  153.     BAD_TYPE                    = kCSBadTypeErr,
  154.     BAD_VCC                        = kCSBadVccErr,
  155.     BAD_VPP                        = kCSBadVppErr,
  156.     BAD_WINDOW                    = kCSBadWindowErr,
  157.     BAD_ARG_LENGTH                = kCSBadArgLengthErr,
  158.     BAD_ARGS                    = kCSBadArgsErr,
  159.     BAD_HANDLE                    = kCSBadHandleErr,
  160.     BAD_CIS                        = kCSBadCISErr,
  161.     BAD_SPEED                    = kCSBadSpeedErr,
  162.     READ_FAILURE                = kCSReadFailureErr,
  163.     WRITE_FAILURE                = kCSWriteFailureErr,
  164.     GENERAL_FAILURE                = kCSGeneralFailureErr,
  165.     NO_CARD                        = kCSNoCardErr,
  166.     UNSUPPORTED_FUNCTION        = kCSUnsupportedFunctionErr,
  167.     UNSUPPORTED_MODE            = kCSUnsupportedModeErr,
  168.     BUSY                        = kCSBusyErr,
  169.     WRITE_PROTECTED                = kCSWriteProtectedErr,
  170.     CONFIGURATION_LOCKED        = kCSConfigurationLockedErr,
  171.     IN_USE                        = kCSInUseErr,
  172.     NO_MORE_ITEMS                = kCSNoMoreItemsErr,
  173.     OUT_OF_RESOURCE                = kCSOutOfResourceErr
  174. };
  175.  
  176.  
  177. /*    messages sent to client's event handler*/
  178.  
  179. enum {
  180.     NULL_MESSAGE                = kCSNullMessage,
  181.     CARD_INSERTION                = kCSCardInsertionMessage,
  182.     CARD_REMOVAL                = kCSCardRemovalMessage,
  183.     CARD_LOCK                    = kCSCardLockMessage,
  184.     CARD_UNLOCK                    = kCSCardUnlockMessage,
  185.     CARD_READY                    = kCSCardReadyMessage,
  186.     CARD_RESET                    = kCSCardResetMessage,
  187.     INSERTION_REQUEST            = kCSInsertionRequestMessage,
  188.     INSERTION_COMPLETE            = kCSInsertionCompleteMessage,
  189.     EJECTION_REQUEST            = kCSEjectionRequestMessage,
  190.     EJECTION_FAILED                = kCSEjectionFailedMessage,
  191.     PM_RESUME                    = kCSPMResumeMessage,
  192.     PM_SUSPEND                    = kCSPMSuspendMessage,
  193.     RESET_PHYSICAL                = kCSResetPhysicalMessage,
  194.     RESET_REQUEST                = kCSResetRequestMessage,
  195.     RESET_COMPLETE                = kCSResetCompleteMessage,
  196.     BATTERY_DEAD                = kCSBatteryDeadMessage,
  197.     BATTERY_LOW                    = kCSBatteryLowMessage,
  198.     WRITE_PROTECT                = kCSWriteProtectMessage,
  199.     WRITE_ENABLED                = kCSWriteEnabledMessage,
  200.     CLIENT_INFO                    = kCSClientInfoMessage,
  201.     SS_UPDATED                    = kCSSSUpdatedMessage,
  202.     FUNCTION_INTERRUPT            = kCSFunctionInterruptMessage,
  203.     ACCESS_ERROR                = kCSAccessErrorMessage,
  204.     CARD_UNCONFIGURED            = kCSCardUnconfiguredMessage,
  205.     STATUS_CHANGED                = kCSStatusChangedMessage
  206. };
  207.  
  208.  
  209. /*----------------        CSAccessConfigurationRegister    ----------------*/
  210.  
  211.  
  212. struct AccessConfigurationRegisterPB {
  213.     UInt16                             socket;                        /*  -> global socket number*/
  214.     UInt8                             action;                        /*  -> read/write*/
  215.     UInt8                             offset;                        /*  -> offset from config register base*/
  216.     UInt8                             value;                        /* <-> value to read/write*/
  217.     UInt8                             padding[1];                    /* */
  218. };
  219. typedef struct AccessConfigurationRegisterPB AccessConfigurationRegisterPB;
  220. /*    'action' field values*/
  221.  
  222. enum {
  223.     kCSReadConfigRegister        = 0x00,
  224.     kCSWriteConfigRegister        = 0x01
  225. };
  226.  
  227.  
  228. /*----------------        CSGetCardServicesInfo            ----------------*/
  229.  
  230.  
  231. struct GetCardServicesInfoPB {
  232.     UInt8                             signature[2];                /* <-  two ascii chars 'CS'*/
  233.     UInt16                             count;                        /* <-  total number of sockets installed*/
  234.     UInt16                             revision;                    /* <-  BCD*/
  235.     UInt16                             csLevel;                    /* <-  BCD*/
  236.     UInt16                             reserved;                    /*  -> zero*/
  237.     UInt16                             vStrLen;                    /* <-> in: client's buffer size, out: vendor string length*/
  238.     UInt8 *                            vendorString;                /* <-> in: pointer to buffer to hold CS vendor string (zero-terminated)*/
  239.                                                                 /*      out: CS vendor string copied to buffer*/
  240. };
  241. typedef struct GetCardServicesInfoPB    GetCardServicesInfoPB;
  242. /*----------------        CSGetClientInfo                    ----------------*/
  243.  
  244.  
  245. /* upper byte of attributes is kCSClientInfoSubfunction*/
  246.  
  247. struct ClientInfoParam {
  248.     UInt32                             clientHandle;                /*  -> clientHandle returned by RegisterClient*/
  249.     UInt16                             attributes;                    /* <-> subfunction + bitmapped client attributes*/
  250.     UInt16                             revision;                    /* <-  BCD value of client's revision*/
  251.     UInt16                             csLevel;                    /* <-  BCD value of CS release*/
  252.     UInt16                             revDate;                    /* <-  revision date: y[15-9], m[8-5], d[4-0]*/
  253.     SInt16                             nameLen;                    /* <-> in: max length of client name string, out: actual length*/
  254.     SInt16                             vStringLen;                    /* <-> in: max length of vendor string, out: actual length*/
  255.     UInt8 *                            nameString;                    /* <-  pointer to client name string (zero-terminated)*/
  256.     UInt8 *                            vendorString;                /* <-  pointer to vendor string (zero-terminated)*/
  257. };
  258. typedef struct ClientInfoParam            ClientInfoParam;
  259. /*
  260.    upper byte of attributes is kCSCardNameSubfunction,
  261.                                  kCSCardTypeSubfunction,
  262.                                  kCSHelpStringSubfunction
  263. */
  264.  
  265. struct AlternateTextStringParam {
  266.     UInt32                             clientHandle;                /*  -> clientHandle returned by RegisterClient*/
  267.     UInt16                             attributes;                    /* <-> subfunction + bitmapped client attributes*/
  268.     UInt16                             socket;                        /*  -> logical socket number*/
  269.     UInt16                             reserved;                    /*  -> zero*/
  270.     SInt16                             length;                        /* <-> in: max length of string, out: actual length*/
  271.     UInt8 *                            text;                        /* <-  pointer to string (zero-terminated)*/
  272. };
  273. typedef struct AlternateTextStringParam    AlternateTextStringParam;
  274. /* upper byte of attributes is kCSCardIconSubfunction*/
  275.  
  276. struct AlternateCardIconParam {
  277.     UInt32                             clientHandle;                /*  -> clientHandle returned by RegisterClient*/
  278.     UInt16                             attributes;                    /* <-> subfunction + bitmapped client attributes*/
  279.     UInt16                             socket;                        /*  -> logical socket number*/
  280.     Handle                             iconSuite;                    /* <-  handle to icon suite containing all icons*/
  281. };
  282. typedef struct AlternateCardIconParam    AlternateCardIconParam;
  283. /* upper byte of attributes is kCSActionProcSubfunction*/
  284.  
  285. struct CustomActionProcParam {
  286.     UInt32                             clientHandle;                /*  -> clientHandle returned by RegisterClient*/
  287.     UInt16                             attributes;                    /* <-> subfunction + bitmapped client attributes*/
  288.     UInt16                             socket;                        /*  -> logical socket number*/
  289. };
  290. typedef struct CustomActionProcParam    CustomActionProcParam;
  291.  
  292. struct GetClientInfoPB {
  293.     union {
  294.         ClientInfoParam                 clientInfo;
  295.         AlternateTextStringParam         alternateTextString;
  296.         AlternateCardIconParam             alternateIcon;
  297.         CustomActionProcParam             customActionProc;
  298.     }                                 u;
  299. };
  300. typedef struct GetClientInfoPB            GetClientInfoPB;
  301. /*    'attributes' field values*/
  302. enum {
  303.     kCSMemoryClient                = 0x0001,
  304.     kCSIOClient                    = 0x0004,
  305.     kCSClientTypeMask            = 0x0007,
  306.     kCSShareableCardInsertEvents = 0x0008,
  307.     kCSExclusiveCardInsertEvents = 0x0010,
  308.     kCSInfoSubfunctionMask        = 0xFF00,
  309.     kCSClientInfoSubfunction    = 0x0000,
  310.     kCSCardNameSubfunction        = 0x8000,
  311.     kCSCardTypeSubfunction        = 0x8100,
  312.     kCSHelpStringSubfunction    = 0x8200,
  313.     kCSCardIconSubfunction        = 0x8300,
  314.     kCSActionProcSubfunction    = 0x8400
  315. };
  316.  
  317.  
  318. /*
  319.   ----------------        CSGetConfigurationInfo            ----------------
  320.   ----------------        CSModifyConfiguration            ----------------
  321.   ----------------        CSRequestConfiguration            ----------------
  322. */
  323.  
  324.  
  325. struct GetModRequestConfigInfoPB {
  326.     UInt32                             clientHandle;                /*  -> clientHandle returned by RegisterClient*/
  327.     UInt16                             socket;                        /*  -> logical socket number*/
  328.     UInt16                             attributes;                    /* <-> bitmap of configuration attributes*/
  329.     UInt8                             vcc;                        /* <-> Vcc setting*/
  330.     UInt8                             vpp1;                        /* <-> Vpp1 setting*/
  331.     UInt8                             vpp2;                        /* <-> Vpp2 setting*/
  332.     UInt8                             intType;                    /* <-> interface type (memory or memory+I/O)*/
  333.     UInt32                             configBase;                    /* <-> card base address of configuration registers*/
  334.     UInt8                             status;                        /* <-> card status register setting, if present*/
  335.     UInt8                             pin;                        /* <-> card pin register setting, if present*/
  336.     UInt8                             copy;                        /* <-> card socket/copy register setting, if present*/
  337.     UInt8                             configIndex;                /* <-> card option register setting, if present*/
  338.     UInt8                             present;                    /* <-> bitmap of which configuration registers are present*/
  339.     UInt8                             firstDevType;                /* <-  from DeviceID tuple*/
  340.     UInt8                             funcCode;                    /* <-  from FuncID tuple*/
  341.     UInt8                             sysInitMask;                /* <-  from FuncID tuple*/
  342.     UInt16                             manufCode;                    /* <-  from ManufacturerID tuple*/
  343.     UInt16                             manufInfo;                    /* <-  from ManufacturerID tuple*/
  344.     UInt8                             cardValues;                    /* <-  valid card register values*/
  345.     UInt8                             padding[1];                    /* */
  346. };
  347. typedef struct GetModRequestConfigInfoPB GetModRequestConfigInfoPB;
  348. /*    'attributes' field values*/
  349. enum {
  350.     kCSExclusivelyUsed            = 0x0001,
  351.     kCSEnableIREQs                = 0x0002,
  352.     kCSVccChangeValid            = 0x0004,
  353.     kCSVpp1ChangeValid            = 0x0008,
  354.     kCSVpp2ChangeValid            = 0x0010,
  355.     kCSValidClient                = 0x0020,
  356.     kCSSleepPower                = 0x0040,                        /* request that power be applied to socket during Sleep*/
  357.     kCSLockSocket                = 0x0080,
  358.     kCSTurnOnInUse                = 0x0100
  359. };
  360.  
  361. /*    'intType' field values*/
  362.  
  363. enum {
  364.     kCSMemoryInterface            = 0x01,
  365.     kCSMemory_And_IO_Interface    = 0x02
  366. };
  367.  
  368. /*    'present' field values*/
  369.  
  370. enum {
  371.     kCSOptionRegisterPresent    = 0x01,
  372.     kCSStatusRegisterPresent    = 0x02,
  373.     kCSPinReplacementRegisterPresent = 0x04,
  374.     kCSCopyRegisterPresent        = 0x08
  375. };
  376.  
  377. /*    'cardValues' field values*/
  378.  
  379. enum {
  380.     kCSOptionValueValid            = 0x01,
  381.     kCSStatusValueValid            = 0x02,
  382.     kCSPinReplacementValueValid    = 0x04,
  383.     kCSCopyValueValid            = 0x08
  384. };
  385.  
  386.  
  387. /*
  388.   ----------------        CSGetClientEventMask            ----------------
  389.   ----------------        CSSetClientEventMask            ----------------
  390. */
  391.  
  392.  
  393. struct GetSetClientEventMaskPB {
  394.     UInt32                             clientHandle;                /*  -> clientHandle returned by RegisterClient*/
  395.     UInt16                             attributes;                    /* <-> bitmap of attributes*/
  396.     UInt16                             eventMask;                    /* <-> bitmap of events to be passed to client for this socket*/
  397.     UInt16                             socket;                        /*  -> logical socket number*/
  398. };
  399. typedef struct GetSetClientEventMaskPB    GetSetClientEventMaskPB;
  400. /*    'attributes' field values*/
  401. enum {
  402.     kCSEventMaskThisSocketOnly    = 0x0001
  403. };
  404.  
  405. /*    'eventMask' field values*/
  406.  
  407. enum {
  408.     kCSWriteProtectEvent        = 0x0001,
  409.     kCSCardLockChangeEvent        = 0x0002,
  410.     kCSEjectRequestEvent        = 0x0004,
  411.     kCSInsertRequestEvent        = 0x0008,
  412.     kCSBatteryDeadEvent            = 0x0010,
  413.     kCSBatteryLowEvent            = 0x0020,
  414.     kCSReadyChangeEvent            = 0x0040,
  415.     kCSCardDetectChangeEvent    = 0x0080,
  416.     kCSPMChangeEvent            = 0x0100,
  417.     kCSResetEvent                = 0x0200,
  418.     kCSSSUpdateEvent            = 0x0400,
  419.     kCSFunctionInterrupt        = 0x0800,
  420.     kCSAllEvents                = 0xFFFF
  421. };
  422.  
  423.  
  424. /*
  425.   ----------------        CSGetFirstClient                ----------------
  426.   ----------------        CSGetNextClient                    ----------------
  427. */
  428.  
  429.  
  430. struct GetClientPB {
  431.     UInt32                             clientHandle;                /* <-  clientHandle for this client*/
  432.     UInt16                             socket;                        /*  -> logical socket number*/
  433.     UInt16                             attributes;                    /*  -> bitmap of attributes*/
  434. };
  435. typedef struct GetClientPB                GetClientPB;
  436. /*    'attributes' field values*/
  437. enum {
  438.     kCSClientsForAllSockets        = 0x0000,
  439.     kCSClientsThisSocketOnly    = 0x0001
  440. };
  441.  
  442.  
  443. /*
  444.   ----------------        CSGetFirstTuple                    ----------------
  445.   ----------------        CSGetNextTuple                    ----------------
  446.   ----------------        CSGetTupleData                    ----------------
  447. */
  448.  
  449.  
  450. struct GetTuplePB {
  451.     UInt16                             socket;                        /*  -> logical socket number*/
  452.     UInt16                             attributes;                    /*  -> bitmap of attributes*/
  453.     UInt8                             desiredTuple;                /*  -> desired tuple code value, or $FF for all*/
  454.     UInt8                             tupleOffset;                /*  -> offset into tuple from link byte*/
  455.     UInt16                             flags;                        /* <-> internal use*/
  456.     UInt32                             linkOffset;                    /* <-> internal use*/
  457.     UInt32                             cisOffset;                    /* <-> internal use*/
  458.  
  459.     union {
  460.         struct {
  461.             UInt8                             tupleCode;            /* <-  tuple code found*/
  462.             UInt8                             tupleLink;            /* <-  link value for tuple found*/
  463.         }                                 TuplePB;
  464.  
  465.         struct {
  466.             UInt16                             tupleDataMax;        /*  -> maximum size of tuple data area*/
  467.             UInt16                             tupleDataLen;        /* <-  number of bytes in tuple body*/
  468.             TupleBody                         tupleData;            /* <-  tuple data*/
  469.         }                                 TupleDataPB;
  470.     }                                 u;
  471. };
  472. typedef struct GetTuplePB                GetTuplePB;
  473. /*    'attributes' field values*/
  474. enum {
  475.     kCSReturnLinkTuples            = 0x0001
  476. };
  477.  
  478.  
  479. /*
  480.   ----------------        CSRequestSocketMask                ----------------
  481.   ----------------        CSReleaseSocketMask                ----------------
  482. */
  483.  
  484.  
  485. struct ReqRelSocketMaskPB {
  486.     UInt32                             clientHandle;                /*  -> clientHandle returned by RegisterClient*/
  487.     UInt16                             socket;                        /*  -> logical socket*/
  488.     UInt16                             eventMask;                    /*  -> bitmap of events to be passed to client for this socket*/
  489. };
  490. typedef struct ReqRelSocketMaskPB        ReqRelSocketMaskPB;
  491. /*    'eventMask' field values (see above for Get/SetClientEventMask*/
  492.  
  493. /*----------------        CSGetStatus                        ----------------*/
  494.  
  495.  
  496. struct GetStatusPB {
  497.     UInt16                             socket;                        /*  -> logical socket number*/
  498.     UInt16                             cardState;                    /* <-  current state of installed card*/
  499.     UInt16                             socketState;                /* <-  current state of the socket*/
  500. };
  501. typedef struct GetStatusPB                GetStatusPB;
  502. /*    'cardState' field values*/
  503. enum {
  504.     kCSWriteProtected            = 0x0001,
  505.     kCSCardLocked                = 0x0002,
  506.     kCSEjectRequest                = 0x0004,
  507.     kCSInsertRequest            = 0x0008,
  508.     kCSBatteryDead                = 0x0010,
  509.     kCSBatteryLow                = 0x0020,
  510.     kCSReady                    = 0x0040,
  511.     kCSCardDetected                = 0x0080
  512. };
  513.  
  514. /*    'socketState' field values*/
  515.  
  516. enum {
  517.     kCSWriteProtectChanged        = 0x0001,
  518.     kCSCardLockChanged            = 0x0002,
  519.     kCSEjectRequestPending        = 0x0004,
  520.     kCSInsertRequestPending        = 0x0008,
  521.     kCSBatteryDeadChanged        = 0x0010,
  522.     kCSBatteryLowChanged        = 0x0020,
  523.     kCSReadyChanged                = 0x0040,
  524.     kCSCardDetectChanged        = 0x0080
  525. };
  526.  
  527.  
  528. /*
  529.   ----------------        CSModifyWindow                    ----------------
  530.   ----------------        CSReleaseWindow                    ----------------
  531.   ----------------        CSRequestWindow                    ----------------
  532. */
  533.  
  534.  
  535. struct ReqModRelWindowPB {
  536.     UInt32                             clientHandle;                /*  -> clientHandle returned by RegisterClient*/
  537.     UInt32                             windowHandle;                /* <-> window descriptor*/
  538.     UInt16                             socket;                        /*  -> logical socket number*/
  539.     UInt16                             attributes;                    /*  -> window attributes (bitmap)*/
  540.     UInt32                             base;                        /* <-> system base address*/
  541.     UInt32                             size;                        /* <-> memory window size*/
  542.     UInt8                             accessSpeed;                /*  -> window access speed (bitmap)*/
  543.                                                                 /*        (not applicable for I/O mode)*/
  544.     UInt8                             padding[1];                    /* */
  545. };
  546. typedef struct ReqModRelWindowPB        ReqModRelWindowPB;
  547. /*    'attributes' field values*/
  548. enum {
  549.     kCSMemoryWindow                = 0x0001,
  550.     kCSIOWindow                    = 0x0002,
  551.     kCSAttributeWindow            = 0x0004,                        /* not normally used by Card Services clients*/
  552.     kCSWindowTypeMask            = 0x0007,
  553.     kCSEnableWindow                = 0x0008,
  554.     kCSAccessSpeedValid            = 0x0010,
  555.     kCSLittleEndian                = 0x0020,                        /* configure socket for little endianess*/
  556.     kCS16BitDataPath            = 0x0040,
  557.     kCSWindowPaged                = 0x0080,                        /* */
  558.     kCSWindowShared                = 0x0100,
  559.     kCSWindowFirstShared        = 0x0200,                        /* */
  560.     kCSWindowProgrammable        = 0x0400                        /* */
  561. };
  562.  
  563. /*    'accessSpeed' field values*/
  564.  
  565. enum {
  566.     kCSDeviceSpeedCodeMask        = 0x07,
  567.     kCSSpeedExponentMask        = 0x07,
  568.     kCSSpeedMantissaMask        = 0x78,
  569.     kCSUseWait                    = 0x80,
  570.     kCSAccessSpeed250nsec        = 0x01,
  571.     kCSAccessSpeed200nsec        = 0x02,
  572.     kCSAccessSpeed150nsec        = 0x03,
  573.     kCSAccessSpeed100nsec        = 0x04,
  574.     kCSExtAccSpeedMant1pt0        = 0x01,
  575.     kCSExtAccSpeedMant1pt2        = 0x02,
  576.     kCSExtAccSpeedMant1pt3        = 0x03,
  577.     kCSExtAccSpeedMant1pt5        = 0x04,
  578.     kCSExtAccSpeedMant2pt0        = 0x05,
  579.     kCSExtAccSpeedMant2pt5        = 0x06,
  580.     kCSExtAccSpeedMant3pt0        = 0x07,
  581.     kCSExtAccSpeedMant3pt5        = 0x08,
  582.     kCSExtAccSpeedMant4pt0        = 0x09,
  583.     kCSExtAccSpeedMant4pt5        = 0x0A,
  584.     kCSExtAccSpeedMant5pt0        = 0x0B,
  585.     kCSExtAccSpeedMant5pt5        = 0x0C,
  586.     kCSExtAccSpeedMant6pt0        = 0x0D,
  587.     kCSExtAccSpeedMant7pt0        = 0x0E,
  588.     kCSExtAccSpeedMant8pt0        = 0x0F,
  589.     kCSExtAccSpeedExp1ns        = 0x00,
  590.     kCSExtAccSpeedExp10ns        = 0x01,
  591.     kCSExtAccSpeedExp100ns        = 0x02,
  592.     kCSExtAccSpeedExp1us        = 0x03,
  593.     kCSExtAccSpeedExp10us        = 0x04,
  594.     kCSExtAccSpeedExp100us        = 0x05,
  595.     kCSExtAccSpeedExp1ms        = 0x06,
  596.     kCSExtAccSpeedExp10ms        = 0x07
  597. };
  598.  
  599.  
  600. /*
  601.   ----------------        CSRegisterClient                ----------------
  602.   ----------------        CSDeregisterClient                ----------------
  603. */
  604.  
  605.  
  606. struct ClientCallbackPB {
  607.     UInt16                             message;                    /*  -> which event this is*/
  608.     UInt16                             socket;                        /*  -> logical socket number*/
  609.     UInt16                             info;                        /*  -> function-specific*/
  610.     UInt16                             misc;                        /*  -> function-specific*/
  611.     Ptr                             reserved;                    /*  -> pointer to MTD request block*/
  612.     Ptr                             buffer;                        /*  -> function-specific*/
  613.     Ptr                             clientData;                    /*  -> pointer to client's data (from RegisterClient)*/
  614. };
  615. typedef struct ClientCallbackPB            ClientCallbackPB;
  616. typedef ClientCallbackPB *                ClientCallbackPBPtr;
  617. typedef CALLBACK_API( UInt16 , PCCardCSClientProcPtr )(ClientCallbackPBPtr ccPBPtr);
  618. typedef STACK_UPP_TYPE(PCCardCSClientProcPtr)                     PCCardCSClientUPP;
  619. #if OPAQUE_UPP_TYPES
  620.     EXTERN_API(PCCardCSClientUPP)
  621.     NewPCCardCSClientUPP           (PCCardCSClientProcPtr    userRoutine);
  622.  
  623.     EXTERN_API(void)
  624.     DisposePCCardCSClientUPP       (PCCardCSClientUPP        userUPP);
  625.  
  626.     EXTERN_API(UInt16)
  627.     InvokePCCardCSClientUPP           (ClientCallbackPBPtr        ccPBPtr,
  628.                                     PCCardCSClientUPP        userUPP);
  629.  
  630. #else
  631.     enum { uppPCCardCSClientProcInfo = 0x000000E0 };                 /* pascal 2_bytes Func(4_bytes) */
  632.     #define NewPCCardCSClientUPP(userRoutine)                         (PCCardCSClientUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppPCCardCSClientProcInfo, GetCurrentArchitecture())
  633.     #define DisposePCCardCSClientUPP(userUPP)                         DisposeRoutineDescriptor(userUPP)
  634.     #define InvokePCCardCSClientUPP(ccPBPtr, userUPP)                 (UInt16)CALL_ONE_PARAMETER_UPP((userUPP), uppPCCardCSClientProcInfo, (ccPBPtr))
  635. #endif
  636. /* support for pre-Carbon UPP routines: NewXXXProc and CallXXXProc */
  637. #define NewPCCardCSClientProc(userRoutine)                         NewPCCardCSClientUPP(userRoutine)
  638. #define CallPCCardCSClientProc(userRoutine, ccPBPtr)            InvokePCCardCSClientUPP(ccPBPtr, userRoutine)
  639.  
  640. struct RegisterClientPB {
  641.     UInt32                             clientHandle;                /* <-  client descriptor*/
  642.     PCCardCSClientUPP                 clientEntry;                /*  -> universal procPtr to client's event handler*/
  643.     UInt16                             attributes;                    /*  -> bitmap of client attributes*/
  644.     UInt16                             eventMask;                    /*  -> bitmap of events to notify client*/
  645.     Ptr                             clientData;                    /*  -> pointer to client's data*/
  646.     UInt16                             version;                    /*  -> Card Services version this client expects*/
  647. };
  648. typedef struct RegisterClientPB            RegisterClientPB;
  649. /*    'attributes' field values (see GetClientInfo)*/
  650. /*
  651.       kCSMemoryClient                    = 0x0001,
  652.       kCSIOClient                        = 0x0004,
  653.       kCSShareableCardInsertEvents    = 0x0008,
  654.       kCSExclusiveCardInsertEvents    = 0x0010
  655. */
  656.  
  657.  
  658. /*----------------        CSReleaseConfiguration            ----------------*/
  659.  
  660.  
  661. struct ReleaseConfigurationPB {
  662.     UInt32                             clientHandle;                /*  -> clientHandle returned by RegisterClient*/
  663.     UInt16                             socket;                        /*  -> */
  664. };
  665. typedef struct ReleaseConfigurationPB    ReleaseConfigurationPB;
  666. /*----------------        CSResetCard                        ----------------*/
  667.  
  668.  
  669. struct ResetCardPB {
  670.     UInt32                             clientHandle;                /*  -> clientHandle returned by RegisterClient*/
  671.     UInt16                             socket;                        /*  -> */
  672.     UInt16                             attributes;                    /*  -> xxx*/
  673. };
  674. typedef struct ResetCardPB                ResetCardPB;
  675. /*----------------        CSValidateCIS                    ----------------*/
  676.  
  677.  
  678. struct ValidateCISPB {
  679.     UInt16                             socket;                        /*  -> */
  680.     UInt16                             chains;                        /*  -> whether link/null tuples should be included*/
  681. };
  682. typedef struct ValidateCISPB            ValidateCISPB;
  683. /*
  684.   ----------------        CSRequestIO                        ----------------
  685.   ----------------        CSReleaseIO                        ----------------
  686. */
  687.  
  688.  
  689. struct ReqRelIOPB {
  690.     UInt32                             clientHandle;                /*  -> clientHandle returned by RegisterClient*/
  691.     UInt16                             socket;                        /*  -> socket number*/
  692.     UInt16                             reserved;
  693.     UInt16                             basePort1;                    /*    ->    base I/O port for range*/
  694.     UInt8                             numPorts1;                    /*    ->    number of ports (e.g., bytes).*/
  695.     UInt8                             attributes1;                /*    ->    attributes*/
  696.  
  697.     UInt16                             basePort2;                    /*    ->    base I/O port for range*/
  698.     UInt8                             numPorts2;                    /*    ->    number of ports*/
  699.     UInt8                             attributes2;                /*    ->    attributes*/
  700.  
  701.     UInt8                             ioAddrLines;                /*    -> number of I/O lines decoded by card*/
  702.     UInt8                             reserved1;
  703. };
  704. typedef struct ReqRelIOPB                ReqRelIOPB;
  705. /*----------------        CSVendorSpecific                ----------------*/
  706.  
  707. struct VendorSpecificPB {
  708.     UInt32                             clientHandle;                /*  -> clientHandle returned by RegisterClient*/
  709.     UInt16                             vsCode;
  710.     UInt16                             socket;
  711.     UInt32                             dataLen;                    /*  -> length of buffer pointed to by vsDataPtr*/
  712.     UInt8 *                            vsDataPtr;                    /*  -> Card Services version this client expects*/
  713. };
  714. typedef struct VendorSpecificPB            VendorSpecificPB;
  715. /*    'vsCode' field values*/
  716.  
  717. enum {
  718.     vsAppleReserved                = 0x0000,
  719.     vsEjectCard                    = 0x0001,
  720.     vsGetCardInfo                = 0x0002,
  721.     vsEnableSocketEvents        = 0x0003,
  722.     vsGetCardLocationIcon        = 0x0004,
  723.     vsGetCardLocationText        = 0x0005,
  724.     vsGetAdapterInfo            = 0x0006
  725. };
  726.  
  727. /*
  728.   ///////////////////////////////////////////////////////////////////////////////////////
  729.       GetAdapterInfo parameter block (vendor-specific call #6)
  730. */
  731.  
  732.  
  733. struct GetAdapterInfoPB {
  734.     UInt32                             attributes;                    /* <-  capabilties of socket's adapter*/
  735.     UInt16                             revision;                    /* <-  id of adapter*/
  736.     UInt16                             reserved;                    /* */
  737.     UInt16                             numVoltEntries;                /* <-  number of valid voltage values*/
  738.     UInt8 *                            voltages;                    /* <-> array of BCD voltage values*/
  739. };
  740. typedef struct GetAdapterInfoPB            GetAdapterInfoPB;
  741. /*    'attributes' field values*/
  742. enum {
  743.     kCSLevelModeInterrupts        = 0x00000001,
  744.     kCSPulseModeInterrupts        = 0x00000002,
  745.     kCSProgrammableWindowAddr    = 0x00000004,
  746.     kCSProgrammableWindowSize    = 0x00000008,
  747.     kCSSocketSleepPower            = 0x00000010,
  748.     kCSSoftwareEject            = 0x00000020,
  749.     kCSLockableSocket            = 0x00000040,
  750.     kCSInUseIndicator            = 0x00000080
  751. };
  752.  
  753. /*
  754.   ///////////////////////////////////////////////////////////////////////////////////////
  755.       GetCardInfo parameter block (vendor-specific call #2)
  756. */
  757.  
  758.  
  759. struct GetCardInfoPB {
  760.     UInt8                             cardType;                    /* <-  type of card in this socket (defined at top of file)*/
  761.     UInt8                             subType;                    /* <-  more detailed card type (defined at top of file)*/
  762.     UInt16                             reserved;                    /* <-> reserved (should be set to zero)*/
  763.     UInt16                             cardNameLen;                /*  -> maximum length of card name to be returned*/
  764.     UInt16                             vendorNameLen;                /*  -> maximum length of vendor name to be returned*/
  765.     UInt8 *                            cardName;                    /*  -> pointer to card name string (read from CIS), or nil*/
  766.     UInt8 *                            vendorName;                    /*  -> pointer to vendor name string (read from CIS), or nil*/
  767. };
  768. typedef struct GetCardInfoPB            GetCardInfoPB;
  769. /*    GetCardInfo card types*/
  770. enum {
  771.     kCSUnknownCardType            = 0,
  772.     kCSMultiFunctionCardType    = 1,
  773.     kCSMemoryCardType            = 2,
  774.     kCSSerialPortCardType        = 3,
  775.     kCSSerialOnlyType            = 0,
  776.     kCSDataModemType            = 1,
  777.     kCSFaxModemType                = 2,
  778.     kCSFaxAndDataModemMask        = (kCSDataModemType | kCSFaxModemType),
  779.     kCSVoiceEncodingType        = 4,
  780.     kCSParallelPortCardType        = 4,
  781.     kCSFixedDiskCardType        = 5,
  782.     kCSUnknownFixedDiskType        = 0,
  783.     kCSATAInterface                = 1,
  784.     kCSRotatingDevice            = (0 << 7),
  785.     kCSSiliconDevice            = (1 << 7),
  786.     kCSVideoAdaptorCardType        = 6,
  787.     kCSNetworkAdaptorCardType    = 7,
  788.     kCSAIMSCardType                = 8,
  789.     kCSNumCardTypes                = 9
  790. };
  791.  
  792.  
  793. #ifndef __PCCARDENABLERPLUGIN__
  794. /*
  795.     NOTE: These prototypes conflict with PCCardEnablerPlugin.*
  796.           You cannot use both PCCardEnablerPlugin.h and CardServices.h
  797.           
  798. */
  799. EXTERN_API( OSErr )
  800. CSVendorSpecific                (VendorSpecificPB *        pb)                                    TWOWORDINLINE(0x7000, 0xAAF0);
  801.  
  802. EXTERN_API( OSErr )
  803. CSRegisterClient                (RegisterClientPB *        pb)                                    TWOWORDINLINE(0x7001, 0xAAF0);
  804.  
  805. EXTERN_API( OSErr )
  806. CSDeregisterClient                (RegisterClientPB *        pb)                                    TWOWORDINLINE(0x7002, 0xAAF0);
  807.  
  808. EXTERN_API( OSErr )
  809. CSGetFirstTuple                    (GetTuplePB *            pb)                                    TWOWORDINLINE(0x7003, 0xAAF0);
  810.  
  811. EXTERN_API( OSErr )
  812. CSGetNextTuple                    (GetTuplePB *            pb)                                    TWOWORDINLINE(0x7004, 0xAAF0);
  813.  
  814. EXTERN_API( OSErr )
  815. CSGetTupleData                    (GetTuplePB *            pb)                                    TWOWORDINLINE(0x7005, 0xAAF0);
  816.  
  817. EXTERN_API( OSErr )
  818. CSGetConfigurationInfo            (GetModRequestConfigInfoPB * pb)                            TWOWORDINLINE(0x7006, 0xAAF0);
  819.  
  820. EXTERN_API( OSErr )
  821. CSGetCardServicesInfo            (GetCardServicesInfoPB * pb)                                TWOWORDINLINE(0x7007, 0xAAF0);
  822.  
  823. EXTERN_API( OSErr )
  824. CSGetStatus                        (GetStatusPB *            pb)                                    TWOWORDINLINE(0x7008, 0xAAF0);
  825.  
  826. EXTERN_API( OSErr )
  827. CSValidateCIS                    (ValidateCISPB *        pb)                                    TWOWORDINLINE(0x7009, 0xAAF0);
  828.  
  829. EXTERN_API( OSErr )
  830. CSGetFirstClient                (GetClientPB *            pb)                                    TWOWORDINLINE(0x700F, 0xAAF0);
  831.  
  832. EXTERN_API( OSErr )
  833. CSGetNextClient                    (GetClientPB *            pb)                                    TWOWORDINLINE(0x7010, 0xAAF0);
  834.  
  835. EXTERN_API( OSErr )
  836. CSGetClientInfo                    (GetClientInfoPB *        pb)                                    TWOWORDINLINE(0x7011, 0xAAF0);
  837.  
  838. EXTERN_API( OSErr )
  839. CSResetCard                        (ResetCardPB *            pb)                                    TWOWORDINLINE(0x7012, 0xAAF0);
  840.  
  841. EXTERN_API( OSErr )
  842. CSRequestWindow                    (ReqModRelWindowPB *    pb)                                    TWOWORDINLINE(0x7013, 0xAAF0);
  843.  
  844. EXTERN_API( OSErr )
  845. CSModifyWindow                    (ReqModRelWindowPB *    pb)                                    TWOWORDINLINE(0x7014, 0xAAF0);
  846.  
  847. EXTERN_API( OSErr )
  848. CSReleaseWindow                    (ReqModRelWindowPB *    pb)                                    TWOWORDINLINE(0x7015, 0xAAF0);
  849.  
  850. EXTERN_API( OSErr )
  851. CSRequestConfiguration            (GetModRequestConfigInfoPB * pb)                            TWOWORDINLINE(0x701B, 0xAAF0);
  852.  
  853. EXTERN_API( OSErr )
  854. CSModifyConfiguration            (GetModRequestConfigInfoPB * pb)                            TWOWORDINLINE(0x701C, 0xAAF0);
  855.  
  856. EXTERN_API( OSErr )
  857. CSAccessConfigurationRegister    (AccessConfigurationRegisterPB * pb)                        TWOWORDINLINE(0x701D, 0xAAF0);
  858.  
  859. EXTERN_API( OSErr )
  860. CSReleaseConfiguration            (ReleaseConfigurationPB * pb)                                TWOWORDINLINE(0x701E, 0xAAF0);
  861.  
  862. EXTERN_API( OSErr )
  863. CSGetClientEventMask            (GetSetClientEventMaskPB * pb)                                TWOWORDINLINE(0x701F, 0xAAF0);
  864.  
  865. EXTERN_API( OSErr )
  866. CSSetClientEventMask            (GetSetClientEventMaskPB * pb)                                TWOWORDINLINE(0x7020, 0xAAF0);
  867.  
  868. EXTERN_API( OSErr )
  869. CSRequestSocketMask                (ReqRelSocketMaskPB *    pb)                                    TWOWORDINLINE(0x7021, 0xAAF0);
  870.  
  871. EXTERN_API( OSErr )
  872. CSReleaseSocketMask                (ReqRelSocketMaskPB *    pb)                                    TWOWORDINLINE(0x7022, 0xAAF0);
  873.  
  874.  
  875. /*
  876.       Additional calls which are required for all I/O clients when running on
  877.       systems which do not reserve dedicated I/O-spaces for each PC Card.
  878. */
  879.  
  880. EXTERN_API( OSErr )
  881. CSRequestIO                        (ReqRelIOPB *            pb)                                    TWOWORDINLINE(0x7025, 0xAAF0);
  882.  
  883. EXTERN_API( OSErr )
  884. CSReleaseIO                        (ReqRelIOPB *            pb)                                    TWOWORDINLINE(0x7026, 0xAAF0);
  885.  
  886. #endif  /* !defined(__PCCARDENABLERPLUGIN__) */
  887.  
  888.  
  889. #if PRAGMA_STRUCT_ALIGN
  890.     #pragma options align=reset
  891. #elif PRAGMA_STRUCT_PACKPUSH
  892.     #pragma pack(pop)
  893. #elif PRAGMA_STRUCT_PACK
  894.     #pragma pack()
  895. #endif
  896.  
  897. #ifdef PRAGMA_IMPORT_OFF
  898. #pragma import off
  899. #elif PRAGMA_IMPORT
  900. #pragma import reset
  901. #endif
  902.  
  903. #ifdef __cplusplus
  904. }
  905. #endif
  906.  
  907. #endif /* __CARDSERVICES__ */
  908.  
  909.